module klang.klang.语法节点.Klang节点_;
import 全局;
import std.conv: ·to = to;
import 节点 = klang.编译.语法节点.节点_;
import klang.编译.核心.核心_: 词典_, 去重数组_, 整数_;
import klang.编译.语法节点.节点_: 访问节点, 访问节点组, 获取基础源文件 = 获取源文件, 节点数组_, 文本字面量_, 令牌_;
import klang.编译.类型.枚举值.枚举值_: SK, TK, 字符_;
import klang.编译.类型.类型_: 流节点_;
import klang.klang.类型.klang类型_: KSK, 版本容器块种类_, AssertFlags, 推理上下文_, 节点标志_, 符号_ = Klang符号_, klang解析的模块名称_;
alias 语句_ = Klang节点_;
alias 声明_ = Klang节点_;
alias 类型节点_ = Klang节点_;
alias 表达式_ = Klang节点_;
alias 标识符_ = Klang标识符_;
alias 修饰符语法_ = KSK;
alias 修饰符_ = Klang令牌_!(KSK);
alias 修饰符数组_ = 节点.节点数组_!(修饰符_);
alias 开放括号表达式_ = Klang节点_;
enum 修饰符标志_ : int {
    无_ = 0,
    恒定_ = 1,
    只读_ = 2,
    共享_ = 4,
    引用_ = 8,
    局部_ = 32,
    静态_ = 64,
    固定_ = 128,
    返回_ = 256,
    公开_ = 512,
    私有_ = 1024,
    保护_ = 2048,
    同步_ = 4096,
    外部_ = 8192,
    重载_ = 16384,
    导出_ = 32768,
    声明_ = 65536,
    纯净_ = 131072,
    安全_ = 262144,
    信任_ = 524288,
    系统_ = 1048576,
    无回收_ = 2097152,
    不抛出_ = 4194304,
    有计算标志 = 536870912,
    返局引_ = 296,
    返引_ = 264,
    返局_ = 288,
    局引_ = 40,
    形参修饰符_ = 296,
    方法修饰符_ = 8310983,
    类或结构修饰符_ = 36903,
    静态只读恒定共享以外的_ = 65448,
    全部_ = 8388591
}
class Klang节点_ : 节点.前端节点_ {
    节点.节点数组_!(修饰符_) 修饰符;
    修饰符标志_ 修饰符缓存;
    /* @internal */ 推理上下文_ 推理上下文; // Inference context for contextual type
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(TK.Klang, tsk, 开始, 结束);
        this.修饰符 = ··null!(节点.节点数组_!(修饰符_));
        this.修饰符缓存 = 修饰符标志_.无_;
        this.推理上下文 = ··null!(推理上下文_);
    }
}
class Klang令牌_(T) : Klang节点_ {
    this() { }
    this(T tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
class 省略表达式_ : Klang节点_ {
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
class Klang标识符_ : Klang节点_ {
    节点.标识符_ 标识符;
    节点.节点数组_!(Klang节点_) 类型实参组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.标识符 = ··null!(节点.标识符_);
        this.类型实参组 = ··null!(节点.节点数组_!(Klang节点_));
    }
    this(节点.标识符_ id) {
        super(KSK.标识符, id.开始, id.结束);
        this.标识符 = id;
        this.类型实参组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 外部修饰符声明_ : 修饰符_ {
    修饰符_ 修饰符节点;
    限定名_ 名称空间;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.修饰符节点 = ··null!(修饰符_);
        this.名称空间 = ··null!(限定名_);
    }
}
class 标识符修饰符_ : 修饰符_ {
    Klang标识符_ 标识符;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.标识符 = ··null!(Klang标识符_);
    }
}
class Klang源文件_ : 节点.源文件_ {
    bool 是声明文件;
    bool 是启动文件;
    词典_!(dstring) 文件设置的版本标识符;
    klang解析的模块名称_ 源文件的包;
    Klang源文件_[] 整合的源文件;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(TK.Klang, tsk, 开始, 结束);
        this.是声明文件 = false;
        this.是启动文件 = false;
        this.文件设置的版本标识符 = ··null!(词典_!(dstring));
        this.源文件的包 = ··null!(klang解析的模块名称_);
        this.整合的源文件 = ··null!(Klang源文件_[]);
    }
}
class 导入声明基类_ : Klang节点_ {
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
class 导入声明_ : 导入声明基类_ {
    节点.节点数组_!(导入成员基类_) 导入组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.导入组 = ··null!(节点.节点数组_!(导入成员基类_));
    }
}
class 导入从声明_ : 导入声明基类_ {
    节点.文本字面量_ 模块名;
    节点.节点数组_!(导入从成员基类_) 导入组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.模块名 = ··null!(节点.文本字面量_);
        this.导入组 = ··null!(节点.节点数组_!(导入从成员基类_));
    }
}
class 导入成员_ : 导入成员基类_ {
    节点.文本字面量_ 模块名;
    Klang标识符_ 另命名名称;
    dstring 包名;
    dstring 符号名;
    bool 是公开的;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.模块名 = ··null!(节点.文本字面量_);
        this.是公开的 = false;
    }
}
class 导入从成员基类_ : Klang节点_ {
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
class 导入成员基类_ : Klang节点_ {
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
class 导入从成员_ : 导入从成员基类_ {
    Klang标识符_ 名称;
    Klang标识符_ 另命名名称;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.另命名名称 = ··null!(Klang标识符_);
    }
}
class 导入版本成员_ : 导入成员基类_ {
    Klang节点_ 表达式;
    bool 是顶级的;
    导入成员块_ 然后语句;
    导入成员基类_ 否则语句;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
        this.是顶级的 = false;
        this.然后语句 = ··null!(导入成员块_);
        this.否则语句 = ··null!(导入成员基类_);
    }
}
class 导入成员块_ : 导入成员基类_ {
    节点.节点数组_!(导入成员基类_) 语句组;
    版本容器块种类_ 版本容器块种类;
    bool 多行;
    bool 是有效的;
    去重数组_!(dstring)[] 版本语句路径;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.语句组 = ··null!(节点.节点数组_!(导入成员基类_));
        this.版本容器块种类 = 版本容器块种类_.无_;
        this.多行 = false;
        this.是有效的 = false;
        this.版本语句路径 = ··null!(去重数组_!(dstring)[]);
    }
}
class 导入从成员块_ : 导入从成员基类_ {
    节点.节点数组_!(导入从成员基类_) 语句组;
    版本容器块种类_ 版本容器块种类;
    bool 多行;
    bool 是有效的;
    去重数组_!(dstring)[] 版本语句路径;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.语句组 = ··null!(节点.节点数组_!(导入从成员基类_));
        this.版本容器块种类 = 版本容器块种类_.无_;
        this.多行 = false;
        this.是有效的 = false;
        this.版本语句路径 = ··null!(去重数组_!(dstring)[]);
    }
}
class 导入从版本成员_ : 导入从成员基类_ {
    Klang节点_ 表达式;
    bool 是顶级的;
    导入从成员块_ 然后语句;
    导入从成员基类_ 否则语句;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
        this.是顶级的 = false;
        this.然后语句 = ··null!(导入从成员块_);
        this.否则语句 = ··null!(导入从成员基类_);
    }
}
class 源码级版本语句_ : Klang节点_ {
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
class 版本表达式语句_ : 源码级版本语句_ {
    Klang标识符_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang标识符_);
    }
}
class 测试单元语句_ : Klang节点_ {
    节点.节点数组_!(Klang节点_) 语句组;
    版本容器块种类_ 版本容器块种类;
    去重数组_!(dstring)[] 版本语句路径;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.语句组 = ··null!(节点.节点数组_!(Klang节点_));
        this.版本容器块种类 = 版本容器块种类_.无_;
        this.版本语句路径 = ··null!(去重数组_!(dstring)[]);
    }
}
class 失踪声明_ : Klang节点_ {
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
class 版本语句_ : 源码级版本语句_ {
    Klang节点_ 表达式;
    bool 是顶级的;
    块_ 然后语句;
    Klang节点_ 否则语句;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
        this.是顶级的 = ··null!(bool);
        this.然后语句 = ··null!(块_);
        this.否则语句 = ··null!(Klang节点_);
    }
}
class 块_ : Klang节点_ {
    节点.节点数组_!(Klang节点_) 语句组;
    版本容器块种类_ 版本容器块种类;
    bool 多行;
    去重数组_!(dstring)[] 版本语句路径;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.语句组 = ··null!(节点.节点数组_!(Klang节点_));
        this.版本容器块种类 = 版本容器块种类_.无_;
        this.多行 = false;
        this.版本语句路径 = ··null!(去重数组_!(dstring)[]);
    }
}
class 指令语句_ : Klang节点_ {
    Klang标识符_ 名称;
    节点.文本字面量_ 参数;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.参数 = ··null!(节点.文本字面量_);
    }
}
class 程序声明_ : Klang节点_ {
    Klang标识符_ 名称;
    bool 是启动声明;
    节点.节点数组_!(Klang节点_) 语句组;
    节点.令牌_!(SK) 结尾令牌;
    函数声明_[] 初始声明;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.语句组 = ··null!(节点.节点数组_!(Klang节点_));
        this.是启动声明 = false;
        this.结尾令牌 = ··null!(节点.令牌_!(SK));
        this.初始声明 = ··null!(函数声明_[]);
    }
}
//#范围 表达式
class 字面量类表达式基类_ : Klang节点_ {
    dstring 内容;
    dstring 原始文本;
    Klang节点_ 文本原节点;
    bool hasExtendedUnicodeEscape = false;
    bool isUnterminated = false;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.内容 = ··null!(dstring);
        this.原始文本 = ··null!(dstring);
        this.文本原节点 = ··null!(Klang节点_);
    }
}
class 模板字面量类节点_ : 字面量类表达式基类_ {
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.目标种类 = tsk;
    }
}
class klang数字字面量_ : 字面量类表达式基类_ {
    ulong 整数值;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.整数值 = 0;
    }
}
class klang小数字面量_ : 字面量类表达式基类_ {
    double 小数值;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.小数值 = ··null!(double);
    }
}
class klang文本字面量_ : 字面量类表达式基类_ {
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
class 字符字面量_ : 字面量类表达式基类_ {
    ulong 字符值;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.字符值 = 0;
    }
}
class 正则表达式字面量_ : 字面量类表达式基类_ {
    dchar 匹配模式;
    节点标志_ 匹配字符标志;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.匹配模式 = 字符_.空字符;
        this.匹配字符标志 = 节点标志_.无;
    }
}
class 无替换模板字面量_ : 模板字面量类节点_ {
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
// `模板头${ 模板中1(xx) }xxxxx${ 模板中2(xx) }模板尾`
class 模板头_ : 模板字面量类节点_ {
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
class 模板中_ : 模板字面量类节点_ {
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
    }
}
class 模板尾_ : 模板字面量类节点_ {
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
    }
}
class 模板表达式_ : 字面量类表达式基类_ {
    模板头_ 模板头;
    节点.节点数组_!(模板中_) 模板跨度;
    模板尾_ 模板尾;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.模板头 = ··null!(模板头_);
        this.模板跨度 = ··null!(节点.节点数组_!(模板中_));
        this.模板尾 = ··null!(模板尾_);
    }
}
class 部分输出表达式_ : Klang节点_ {
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
    }
}
class 前缀一元表达式_ : Klang节点_ {
    KSK 运算符;
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.运算符 = KSK.未知__;
        this.表达式 = ··null!(Klang节点_);
    }
}
class 后缀一元表达式_ : Klang节点_ {
    KSK 运算符;
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.运算符 = KSK.未知__;
        this.表达式 = ··null!(Klang节点_);
    }
}
class 二元表达式_ : Klang节点_ {
    Klang节点_ 左侧;
    KSK 运算符;
    Klang节点_ 右侧;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.左侧 = ··null!(Klang节点_);
        this.运算符 = KSK.未知__;
        this.右侧 = ··null!(Klang节点_);
    }
}
class 条件表达式_ : Klang节点_ {
    Klang节点_ 条件;
    KSK 问号;
    Klang节点_ 当真;
    KSK 冒号;
    Klang节点_ 当假;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.条件 = ··null!(Klang节点_);
        this.问号 = KSK.未知__;
        this.当真 = ··null!(Klang节点_);
        this.冒号 = KSK.未知__;
        this.当假 = ··null!(Klang节点_);
    }
}
class 属性访问表达式_ : Klang节点_ {
    Klang节点_ 左侧;
    Klang标识符_ 名称;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.左侧 = ··null!(Klang节点_);
        this.名称 = ··null!(Klang标识符_);
    }
}
//#结束范围
class 限定名_ : Klang节点_ {
    限定名_ 左侧;
    Klang标识符_ 右侧;
    /*@internal*/ long jsdocDotPos = -1;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.左侧 = ··null!(限定名_);
        this.右侧 = ··null!(Klang标识符_);
    }
}
class 类型引用_ : Klang节点_ {
    限定名_ 类型名称;
    节点.节点数组_!(Klang节点_) 类型实参组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型名称 = ··null!(限定名_);
    }
}
class 静态二元表达式类型节点_ : Klang节点_ {
    Klang节点_ 左侧;
    KSK 运算符;
    Klang节点_ 右侧;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.左侧 = ··null!(Klang节点_);
        this.运算符 = KSK.未知__;
        this.右侧 = ··null!(Klang节点_);
    }
}
class 类型形参_ : Klang节点_ {
    Klang标识符_ 名称;
    Klang节点_ 约束;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.约束 = ··null!(Klang节点_);
    }
}
class 形参声明_ : Klang节点_ {
    Klang标识符_ 名称;
    Klang节点_ 类型;
    KSK 问号;
    Klang节点_ 初始化;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.类型 = ··null!(Klang节点_);
        this.问号 = KSK.未知__;
    }
}
class 签名声明_ : Klang节点_ {
    节点.节点数组_!(类型形参_) 类型形参;
    节点.节点数组_!(形参声明_) 形参组;
    Klang节点_ 类型;
    节点.节点数组_!(Klang节点_) 类型实参组;
    符号_[] 合成形参组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.目标种类 = tsk;
        this.类型形参 = ··null!(节点.节点数组_!(类型形参_));
        this.形参组 = ··null!(节点.节点数组_!(形参声明_));
        this.类型 = ··null!(Klang节点_);
        this.类型实参组 = ··null!(节点.节点数组_!(Klang节点_));
        this.合成形参组 = ··null!(符号_[]);
    }
}
class 函数类型_ : 签名声明_ {
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.目标种类 = tsk;
    }
}
class 函数类声明_ : 签名声明_ {
    节点.节点_ 函数体;
    流节点_ 结尾流;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.函数体 = ··null!(节点.节点_);
        this.结尾流 = ··null!(流节点_);
    }
}
class 区间类型节点_ : Klang节点_ {
    Klang节点_ 区间开始;
    Klang节点_ 区间结束;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.区间开始 = ··null!(Klang节点_);
        this.区间结束 = ··null!(Klang节点_);
    }
}
class 数组类型_ : Klang节点_ {
    Klang节点_ 类型;
    Klang节点_ 长度;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型 = ··null!(Klang节点_);
        this.长度 = ··null!(Klang节点_);
    }
}
class 元组类型节点_ : Klang节点_ {
    节点.节点数组_!(Klang节点_) 类型组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 类型列表_ : Klang节点_ {
    节点.节点数组_!(Klang节点_) 类型组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 联合类型_ : Klang节点_ {
    节点.节点数组_!(Klang节点_) 类型组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 括号类型_ : Klang节点_ {
    Klang节点_ 类型;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型 = ··null!(Klang节点_);
    }
}
class 词典类型_ : Klang节点_ {
    Klang节点_ 值类型;
    Klang节点_ 键类型;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.值类型 = ··null!(Klang节点_);
        this.键类型 = ··null!(Klang节点_);
    }
}
class 动态数组类型_ : Klang节点_ {
    Klang节点_ 类型;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型 = ··null!(Klang节点_);
    }
}
class 指针类型_ : Klang节点_ {
    Klang节点_ 类型;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型 = ··null!(Klang节点_);
    }
}
class 变长参数_ : Klang节点_ {
    Klang节点_ 类型;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型 = ··null!(Klang节点_);
    }
}
class 类型限定类型_ : Klang节点_ {
    KSK 限定符;
    Klang节点_ 类型;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.限定符 = KSK.未知__;
        this.类型 = ··null!(Klang节点_);
    }
}
class 字面量类型_ : Klang节点_ {
    Klang节点_ 字面量;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.字面量 = ··null!(Klang节点_);
    }
}
class 类型查询表达式_ : Klang节点_ {
    Klang节点_ 表达式;
    Klang节点_ 类型;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
        this.类型 = ··null!(Klang节点_);
    }
}
class 类型断言表达式_ : Klang节点_ {
    Klang节点_ 表达式;
    Klang节点_ 类型;
    AssertFlags 断言标志;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
        this.类型 = ··null!(Klang节点_);
        this.断言标志 = AssertFlags.无_;
    }
}
class 展开表达式_ : Klang节点_ {
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
    }
}
class 非空表达式_ : Klang节点_ {
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
    }
}
class 类型转换表达式_ : Klang节点_ {
    Klang节点_ 表达式;
    Klang节点_ 类型;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
        this.类型 = ··null!(Klang节点_);
    }
}
class 箭头函数_ : 函数类声明_ {
    Klang令牌_!(KSK) 等右尖号;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.函数体 = ··null!(节点.节点_);
        this.等右尖号 = ··null!(Klang令牌_!(KSK));
    }
}
class 函数表达式_ : 函数类声明_ {
    Klang标识符_ 名称;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.函数体 = ··null!(节点.节点_);
    }
}
class 函数声明_ : 函数类声明_ {
    Klang标识符_ 名称;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.函数体 = ··null!(节点.节点_);
        this.类型形参 = ··null!(节点.节点数组_!(类型形参_));
    }
}
class 构建声明_ : 函数类声明_ {
    Klang标识符_ 名称;
    流节点_ 返回流节点;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.函数体 = ··null!(节点.节点_);
        this.返回流节点 = ··null!(流节点_);
    }
}
class 释放声明_ : 函数类声明_ {
    Klang标识符_ 名称;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.函数体 = ··null!(节点.节点_);
    }
}
class 命名声明_ : Klang节点_ {
    Klang标识符_ 名称;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
    }
}
class 接口声明_ : 命名声明_ {
    节点.节点数组_!(类型形参_) 类型形参;
    节点.节点数组_!(继承子句_) 继承子句;
    节点.节点数组_!(Klang节点_) 成员组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.类型形参 = ··null!(节点.节点数组_!(类型形参_));
        this.继承子句 = ··null!(节点.节点数组_!(继承子句_));
        this.成员组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 枚举成员_ : 命名声明_ {
    Klang节点_ 初始化;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.初始化 = ··null!(Klang节点_);
    }
}
class 枚举声明_ : 命名声明_ {
    Klang节点_ 类型;
    节点.节点数组_!(枚举成员_) 成员组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.类型 = ··null!(Klang节点_);
        this.成员组 = ··null!(节点.节点数组_!(枚举成员_));
    }
}
class 对象声明_ : 命名声明_ {
    节点.节点数组_!(类型形参_) 类型形参;
    节点.节点数组_!(继承子句_) 继承子句;
    节点.节点数组_!(Klang节点_) 成员组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.类型形参 = ··null!(节点.节点数组_!(类型形参_));
        this.继承子句 = ··null!(节点.节点数组_!(继承子句_));
        this.成员组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 结构声明_ : 命名声明_ {
    节点.节点数组_!(类型形参_) 类型形参;
    节点.节点数组_!(继承子句_) 继承子句;
    节点.节点数组_!(Klang节点_) 成员组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.类型形参 = ··null!(节点.节点数组_!(类型形参_));
        this.继承子句 = ··null!(节点.节点数组_!(继承子句_));
        this.成员组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 类型声明_ : 命名声明_ {
    节点.节点数组_!(类型形参_) 类型形参;
    Klang节点_ 类型;
    节点.节点数组_!(Klang节点_) 成员组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.类型形参 = ··null!(节点.节点数组_!(类型形参_));
        this.类型 = ··null!(Klang节点_);
        this.成员组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 属性声明_ : 命名声明_ {
    Klang节点_ 类型;
    Klang节点_ 初始化;
    KSK 问号;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.类型 = ··null!(Klang节点_);
        this.初始化 = ··null!(Klang节点_);
        this.问号 = KSK.未知__;
    }
}
class 方法声明_ : 函数类声明_ {
    Klang标识符_ 名称;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.类型形参 = ··null!(节点.节点数组_!(类型形参_));
    }
}
class 别名声明_ : 命名声明_ {
    节点.节点数组_!(类型形参_) 类型形参;
    Klang节点_ 类型;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.类型形参 = ··null!(节点.节点数组_!(类型形参_));
        this.类型 = ··null!(Klang节点_);
    }
}
class 索引签名_ : Klang节点_ {
    形参声明_ 形参;
    Klang节点_ 类型;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.形参 = ··null!(形参声明_);
        this.类型 = ··null!(Klang节点_);
    }
}
class 运算符签名_ : Klang节点_ {
    节点.节点数组_!(运算符签名元素_) 运算符组;
    Klang节点_ 类型;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型 = ··null!(Klang节点_);
        this.运算符组 = ··null!(节点.节点数组_!(运算符签名元素_));
    }
}
class 运算符签名元素_ : Klang节点_ {
    KSK 运算符;
    Klang节点_ 类型;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型 = ··null!(Klang节点_);
        this.运算符 = KSK.未知__;
    }
}
class 数组字面量表达式_ : Klang节点_ {
    节点.节点数组_!(Klang节点_) 元素组;
    bool 多行;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.元素组 = ··null!(节点.节点数组_!(Klang节点_));
        this.多行 = false;
    }
}
class 动态类字面量表达式_ : Klang节点_ {
    节点.节点数组_!(Klang节点_) 元素组;
    bool 多行;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.元素组 = ··null!(节点.节点数组_!(Klang节点_));
        this.多行 = false;
    }
}
class 词典键值表达式_ : Klang节点_ {
    Klang节点_ 键表达式;
    Klang节点_ 值表达式;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.键表达式 = ··null!(Klang节点_);
        this.值表达式 = ··null!(Klang节点_);
    }
}
class 截取表达式_ : Klang节点_ {
    Klang节点_ 表达式;
    Klang节点_ 截取开始;
    Klang节点_ 截取结尾;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
        this.截取开始 = ··null!(Klang节点_);
        this.截取结尾 = ··null!(Klang节点_);
    }
}
class 元素访问表达式_ : Klang节点_ {
    Klang节点_ 表达式;
    Klang节点_ 参数表达式;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
        this.参数表达式 = ··null!(Klang节点_);
    }
}
class 接口字面量表达式_ : Klang节点_ {
    节点.节点数组_!(Klang节点_) 属性组;
    Klang节点_ 类型;
    bool 多行;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型 = ··null!(Klang节点_);
        this.属性组 = ··null!(节点.节点数组_!(Klang节点_));
        this.多行 = false;
    }
}
class 结构字面量表达式_ : Klang节点_ {
    节点.节点数组_!(Klang节点_) 属性组;
    Klang节点_ 类型注释节点;
    bool 多行;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型注释节点 = ··null!(Klang节点_);
        this.属性组 = ··null!(节点.节点数组_!(Klang节点_));
        this.多行 = false;
    }
}
class 新建表达式_ : Klang节点_ {
    Klang节点_ 类型;
    节点.节点数组_!(Klang节点_) 实参组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型 = ··null!(Klang节点_);
        this.实参组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 调用表达式_ : Klang节点_ {
    Klang节点_ 表达式;
    节点.节点数组_!(Klang节点_) 类型实参组;
    节点.节点数组_!(Klang节点_) 实参组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
        this.类型实参组 = ··null!(节点.节点数组_!(Klang节点_));
        this.实参组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 属性赋值_ : Klang节点_ {
    Klang标识符_ 名称;
    Klang节点_ 初始化;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.初始化 = ··null!(Klang节点_);
    }
}
class 简洁属性赋值_ : Klang节点_ {
    Klang标识符_ 名称;
    KSK 等号;
    Klang节点_ 初始化;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.等号 = KSK.未知__;
        this.初始化 = ··null!(Klang节点_);
    }
}
class 表达式包含类型实参_ : Klang节点_ {
    Klang节点_ 表达式;
    节点.节点数组_!(Klang节点_) 类型实参组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
        this.类型实参组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 继承子句_ : Klang节点_ {
    节点.节点数组_!(表达式包含类型实参_) 类型组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.类型组 = ··null!(节点.节点数组_!(表达式包含类型实参_));
    }
}
class 符号引用表达式_ : Klang节点_ {
    Klang标识符_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang标识符_);
    }
}
class 变量声明_ : 命名声明_ {
    Klang节点_ 类型;
    Klang节点_ 初始化;
    Klang令牌_!(KSK) 叹号令牌;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.名称 = ··null!(Klang标识符_);
        this.类型 = ··null!(Klang节点_);
        this.叹号令牌 = ··null!(Klang令牌_!(KSK));
        this.初始化 = ··null!(Klang节点_);
    }
}
class 变量语句_ : Klang节点_ {
    变量声明列表_ 声明列表;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.声明列表 = ··null!(变量声明列表_);
    }
}
class 变量声明列表_ : Klang节点_ {
    节点.节点数组_!(变量声明_) 声明组;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.声明组 = ··null!(节点.节点数组_!(变量声明_));
    }
}
class 空语句_ : Klang节点_ {
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
class 如果语句_ : Klang节点_ {
    Klang节点_ 表达式;
    Klang节点_ 然后语句;
    Klang节点_ 否则语句;
    this() { }
    this(KSK tsk, long 开始 = -1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
        this.然后语句 = ··null!(Klang节点_);
        this.否则语句 = ··null!(Klang节点_);
    }
}
class 迭代类语句_ : Klang节点_ {
    Klang节点_ 语句;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.语句 = ··null!(Klang节点_);
    }
}
class 循环属于_ : 迭代类语句_ {
    Klang节点_ 初始化;
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.初始化 = ··null!(Klang节点_);
        this.表达式 = ··null!(Klang节点_);
    }
}
class 循环语句_ : 迭代类语句_ {
    Klang节点_ 初始化;
    Klang节点_ 条件;
    Klang节点_ 自增;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.初始化 = ··null!(Klang节点_);
        this.条件 = ··null!(Klang节点_);
        this.自增 = ··null!(Klang节点_);
    }
}
class 当循环语句_ : 迭代类语句_ {
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
    }
}
class 表达式列表表达式_ : Klang节点_ {
    节点.节点数组_!(Klang节点_) 元素组;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.元素组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 跳出语句_ : Klang节点_ {
    Klang标识符_ 标签;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.标签 = ··null!(Klang标识符_);
    }
}
class 继续语句_ : Klang节点_ {
    Klang标识符_ 标签;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.标签 = ··null!(Klang标识符_);
    }
}
class 延迟语句_ : Klang节点_ {
    Klang节点_ 语句;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.语句 = ··null!(Klang节点_);
    }
}
class 删除语句_ : Klang节点_ {
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
    }
}
class 返回语句_ : Klang节点_ {
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
    }
}
class 假如语句_ : Klang节点_ {
    Klang节点_ 表达式;
    若是块_ 若是块;
    bool possiblyExhaustive;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
        this.若是块 = ··null!(若是块_);
        this.possiblyExhaustive = false;
    }
}
class 若是或默认子句_ : Klang节点_ {
    节点.节点数组_!(Klang节点_) 语句组;
    流节点_ fallthroughFlowNode;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.语句组 = ··null!(节点.节点数组_!(Klang节点_));
        this.fallthroughFlowNode = ··null!(流节点_);
    }
}
class 若是子句_ : 若是或默认子句_ {
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
    }
}
class 默认子句_ : 若是或默认子句_ {
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
class 若是块_ : Klang节点_ {
    节点.节点数组_!(若是或默认子句_) 子句组;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.子句组 = ··null!(节点.节点数组_!(若是或默认子句_));
    }
}
class 抛出语句_ : Klang节点_ {
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
    }
}
class 断言语句_ : Klang节点_ {
    节点.节点数组_!(Klang节点_) 实参组;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.实参组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 同步语句_ : Klang节点_ {
    节点.节点数组_!(Klang节点_) 实参组;
    节点.节点数组_!(Klang节点_) 语句组;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.实参组 = ··null!(节点.节点数组_!(Klang节点_));
        this.语句组 = ··null!(节点.节点数组_!(Klang节点_));
    }
}
class 尝试语句_ : Klang节点_ {
    块_ 尝试块;
    捕获子句_ 捕获子句;
    块_ 最后块;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.尝试块 = ··null!(块_);
        this.捕获子句 = ··null!(捕获子句_);
        this.最后块 = ··null!(块_);
    }
}
class 捕获子句_ : Klang节点_ {
    Klang节点_ 变量声明;
    块_ 块;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.变量声明 = ··null!(Klang节点_);
        this.块 = ··null!(块_);
    }
}
class 调试语句_ : Klang节点_ {
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
class 标签语句_ : Klang节点_ {
    Klang标识符_ 标签;
    Klang节点_ 语句;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.标签 = ··null!(Klang标识符_);
        this.语句 = ··null!(Klang节点_);
    }
}
class 表达式语句_ : Klang节点_ {
    Klang节点_ 表达式;
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
        this.表达式 = ··null!(Klang节点_);
    }
}
class 合成注释_ : Klang节点_ {
    this() { }
    this(KSK tsk, long 开始 = 1, long 结束 = -1) {
        super(tsk, 开始, 结束);
    }
}
Klang源文件_ 创建源文件() {
    return new Klang源文件_(KSK.源文件);
}
T 创建节点(T)(KSK tsk, long 开始 = -1, long 结束 = -1) {
    switch (tsk) {
        case KSK.标识符: {
            return (cast(T)(new Klang标识符_(tsk, 开始, 结束)));
        }
        case KSK.导入成员: {
            return (cast(T)(new 导入成员_(tsk, 开始, 结束)));
        }
        case KSK.导入从成员: {
            return (cast(T)(new 导入从成员_(tsk, 开始, 结束)));
        }
        case KSK.导入声明: {
            return (cast(T)(new 导入声明_(tsk, 开始, 结束)));
        }
        case KSK.导入从声明: {
            return (cast(T)(new 导入从声明_(tsk, 开始, 结束)));
        }
        case KSK.导入版本成员: {
            return (cast(T)(new 导入版本成员_(tsk, 开始, 结束)));
        }
        case KSK.导入成员块: {
            return (cast(T)(new 导入成员块_(tsk, 开始, 结束)));
        }
        case KSK.导入从成员块: {
            return (cast(T)(new 导入从成员块_(tsk, 开始, 结束)));
        }
        case KSK.导入从版本成员: {
            return (cast(T)(new 导入从版本成员_(tsk, 开始, 结束)));
        }
        case KSK.版本表达式语句: {
            return (cast(T)(new 版本表达式语句_(tsk, 开始, 结束)));
        }
        case KSK.版本语句: {
            return (cast(T)(new 版本语句_(tsk, 开始, 结束)));
        }
        case KSK.块: {
            return (cast(T)(new 块_(tsk, 开始, 结束)));
        }
        case KSK.合成注释: {
            return (cast(T)(new 合成注释_(tsk, 开始, 结束)));
        }
        case KSK.程序声明: {
            return (cast(T)(new 程序声明_(tsk, 开始, 结束)));
        }
        case KSK.变量语句: {
            return (cast(T)(new 变量语句_(tsk, 开始, 结束)));
        }
        case KSK.变量声明列表: {
            return (cast(T)(new 变量声明列表_(tsk, 开始, 结束)));
        }
        case KSK.变量声明: {
            return (cast(T)(new 变量声明_(tsk, 开始, 结束)));
        }
        case KSK.数字字面量: {
            return (cast(T)(new klang数字字面量_(tsk, 开始, 结束)));
        }
        case KSK.文本字面量: {
            return (cast(T)(new klang文本字面量_(tsk, 开始, 结束)));
        }
        case KSK.字符字面量: {
            return (cast(T)(new 字符字面量_(tsk, 开始, 结束)));
        }
        case KSK.无替换模板字面量: {
            return (cast(T)(new 无替换模板字面量_(tsk, 开始, 结束)));
        }
        case KSK.模板表达式: {
            return (cast(T)(new 模板表达式_(tsk, 开始, 结束)));
        }
        case KSK.模板头: {
            return (cast(T)(new 模板头_(tsk, 开始, 结束)));
        }
        case KSK.模板中: {
            return (cast(T)(new 模板中_(tsk, 开始, 结束)));
        }
        case KSK.模板尾: {
            return (cast(T)(new 模板尾_(tsk, 开始, 结束)));
        }
        case KSK.二元表达式: {
            return (cast(T)(new 二元表达式_(tsk, 开始, 结束)));
        }
        case KSK.函数声明: {
            return (cast(T)(new 函数声明_(tsk, 开始, 结束)));
        }
        case KSK.方法声明: {
            return (cast(T)(new 方法声明_(tsk, 开始, 结束)));
        }
        case KSK.构建声明: {
            return (cast(T)(new 构建声明_(tsk, 开始, 结束)));
        }
        case KSK.释放声明: {
            return (cast(T)(new 释放声明_(tsk, 开始, 结束)));
        }
        case KSK.枚举声明: {
            return (cast(T)(new 枚举声明_(tsk, 开始, 结束)));
        }
        case KSK.接口声明: {
            return (cast(T)(new 接口声明_(tsk, 开始, 结束)));
        }
        case KSK.对象声明: {
            return (cast(T)(new 对象声明_(tsk, 开始, 结束)));
        }
        case KSK.结构声明: {
            return (cast(T)(new 结构声明_(tsk, 开始, 结束)));
        }
        case KSK.类型声明: {
            return (cast(T)(new 类型声明_(tsk, 开始, 结束)));
        }
        case KSK.别名声明: {
            return (cast(T)(new 别名声明_(tsk, 开始, 结束)));
        }
        case KSK.继承子句: {
            return (cast(T)(new 继承子句_(tsk, 开始, 结束)));
        }
        case KSK.索引签名: {
            return (cast(T)(new 索引签名_(tsk, 开始, 结束)));
        }
        case KSK.运算符签名: {
            return (cast(T)(new 运算符签名_(tsk, 开始, 结束)));
        }
        case KSK.运算符签名元素: {
            return (cast(T)(new 运算符签名元素_(tsk, 开始, 结束)));
        }
        case KSK.测试单元语句: {
            return (cast(T)(new 测试单元语句_(tsk, 开始, 结束)));
        }
        case KSK.失踪声明: {
            return (cast(T)(new 失踪声明_(tsk, 开始, 结束)));
        }
        case KSK.外部修饰符声明: {
            return (cast(T)(new 外部修饰符声明_(tsk, 开始, 结束)));
        }
        case KSK.标识符修饰符: {
            return (cast(T)(new 标识符修饰符_(tsk, 开始, 结束)));
        }
        case KSK.空语句: {
            return (cast(T)(new 空语句_(tsk, 开始, 结束)));
        }
        case KSK.如果语句: {
            return (cast(T)(new 如果语句_(tsk, 开始, 结束)));
        }
        case KSK.循环属于: {
            return (cast(T)(new 循环属于_(tsk, 开始, 结束)));
        }
        case KSK.循环语句: {
            return (cast(T)(new 循环语句_(tsk, 开始, 结束)));
        }
        case KSK.当循环语句: {
            return (cast(T)(new 当循环语句_(tsk, 开始, 结束)));
        }
        case KSK.跳出语句: {
            return (cast(T)(new 跳出语句_(tsk, 开始, 结束)));
        }
        case KSK.继续语句: {
            return (cast(T)(new 继续语句_(tsk, 开始, 结束)));
        }
        case KSK.延迟语句: {
            return (cast(T)(new 延迟语句_(tsk, 开始, 结束)));
        }
        case KSK.删除语句: {
            return (cast(T)(new 删除语句_(tsk, 开始, 结束)));
        }
        case KSK.返回语句: {
            return (cast(T)(new 返回语句_(tsk, 开始, 结束)));
        }
        case KSK.假如语句: {
            return (cast(T)(new 假如语句_(tsk, 开始, 结束)));
        }
        case KSK.若是块: {
            return (cast(T)(new 若是块_(tsk, 开始, 结束)));
        }
        case KSK.抛出语句: {
            return (cast(T)(new 抛出语句_(tsk, 开始, 结束)));
        }
        case KSK.断言语句: {
            return (cast(T)(new 断言语句_(tsk, 开始, 结束)));
        }
        case KSK.同步语句: {
            return (cast(T)(new 同步语句_(tsk, 开始, 结束)));
        }
        case KSK.尝试语句: {
            return (cast(T)(new 尝试语句_(tsk, 开始, 结束)));
        }
        case KSK.捕获子句: {
            return (cast(T)(new 捕获子句_(tsk, 开始, 结束)));
        }
        case KSK.调试语句: {
            return (cast(T)(new 调试语句_(tsk, 开始, 结束)));
        }
        case KSK.标签语句: {
            return (cast(T)(new 标签语句_(tsk, 开始, 结束)));
        }
        case KSK.表达式语句: {
            return (cast(T)(new 表达式语句_(tsk, 开始, 结束)));
        }
        case KSK.表达式列表表达式: {
            return (cast(T)(new 表达式列表表达式_(tsk, 开始, 结束)));
        }
        case KSK.类型形参: {
            return (cast(T)(new 类型形参_(tsk, 开始, 结束)));
        }
        case KSK.形参声明: {
            return (cast(T)(new 形参声明_(tsk, 开始, 结束)));
        }
        case KSK.类型引用: {
            return (cast(T)(new 类型引用_(tsk, 开始, 结束)));
        }
        case KSK.符号引用表达式: {
            return (cast(T)(new 符号引用表达式_(tsk, 开始, 结束)));
        }
        case KSK.元组类型节点: {
            return (cast(T)(new 元组类型节点_(tsk, 开始, 结束)));
        }
        case KSK.属性访问表达式: {
            return (cast(T)(new 属性访问表达式_(tsk, 开始, 结束)));
        }
        case KSK.新建表达式: {
            return (cast(T)(new 新建表达式_(tsk, 开始, 结束)));
        }
        case KSK.调用表达式: {
            return (cast(T)(new 调用表达式_(tsk, 开始, 结束)));
        }
        case KSK.限定名: {
            return (cast(T)(new 限定名_(tsk, 开始, 结束)));
        }
        case KSK.前缀一元表达式: {
            return (cast(T)(new 前缀一元表达式_(tsk, 开始, 结束)));
        }
        case KSK.后缀一元表达式: {
            return (cast(T)(new 后缀一元表达式_(tsk, 开始, 结束)));
        }
        case KSK.元素访问表达式: {
            return (cast(T)(new 元素访问表达式_(tsk, 开始, 结束)));
        }
        case KSK.类型转换表达式: {
            return (cast(T)(new 类型转换表达式_(tsk, 开始, 结束)));
        }
        case KSK.静态二元表达式类型节点: {
            return (cast(T)(new 静态二元表达式类型节点_(tsk, 开始, 结束)));
        }
        case KSK.函数类型: {
            return (cast(T)(new 函数类型_(tsk, 开始, 结束)));
        }
        case KSK.区间类型节点: {
            return (cast(T)(new 区间类型节点_(tsk, 开始, 结束)));
        }
        case KSK.数组类型: {
            return (cast(T)(new 数组类型_(tsk, 开始, 结束)));
        }
        case KSK.类型列表: {
            return (cast(T)(new 类型列表_(tsk, 开始, 结束)));
        }
        case KSK.联合类型: {
            return (cast(T)(new 联合类型_(tsk, 开始, 结束)));
        }
        case KSK.括号类型: {
            return (cast(T)(new 括号类型_(tsk, 开始, 结束)));
        }
        case KSK.词典类型: {
            return (cast(T)(new 词典类型_(tsk, 开始, 结束)));
        }
        case KSK.动态数组类型: {
            return (cast(T)(new 动态数组类型_(tsk, 开始, 结束)));
        }
        case KSK.指针类型: {
            return (cast(T)(new 指针类型_(tsk, 开始, 结束)));
        }
        case KSK.变长参数: {
            return (cast(T)(new 变长参数_(tsk, 开始, 结束)));
        }
        case KSK.类型限定类型: {
            return (cast(T)(new 类型限定类型_(tsk, 开始, 结束)));
        }
        case KSK.字面量类型: {
            return (cast(T)(new 字面量类型_(tsk, 开始, 结束)));
        }
        case KSK.指令语句: {
            return (cast(T)(new 指令语句_(tsk, 开始, 结束)));
        }
        case KSK.枚举成员: {
            return (cast(T)(new 枚举成员_(tsk, 开始, 结束)));
        }
        case KSK.属性声明: {
            return (cast(T)(new 属性声明_(tsk, 开始, 结束)));
        }
        case KSK.小数字面量: {
            return (cast(T)(new klang小数字面量_(tsk, 开始, 结束)));
        }
        case KSK.正则表达式字面量: {
            return (cast(T)(new 正则表达式字面量_(tsk, 开始, 结束)));
        }
        case KSK.数组字面量表达式: {
            return (cast(T)(new 数组字面量表达式_(tsk, 开始, 结束)));
        }
        case KSK.动态类字面量表达式: {
            return (cast(T)(new 动态类字面量表达式_(tsk, 开始, 结束)));
        }
        case KSK.词典键值表达式: {
            return (cast(T)(new 词典键值表达式_(tsk, 开始, 结束)));
        }
        case KSK.接口字面量表达式: {
            return (cast(T)(new 接口字面量表达式_(tsk, 开始, 结束)));
        }
        case KSK.函数表达式: {
            return (cast(T)(new 函数表达式_(tsk, 开始, 结束)));
        }
        case KSK.非空表达式: {
            return (cast(T)(new 非空表达式_(tsk, 开始, 结束)));
        }
        case KSK.截取表达式: {
            return (cast(T)(new 截取表达式_(tsk, 开始, 结束)));
        }
        case KSK.展开表达式: {
            return (cast(T)(new 展开表达式_(tsk, 开始, 结束)));
        }
        case KSK.属性赋值: {
            return (cast(T)(new 属性赋值_(tsk, 开始, 结束)));
        }
        case KSK.简洁属性赋值: {
            return (cast(T)(new 简洁属性赋值_(tsk, 开始, 结束)));
        }
        case KSK.条件表达式: {
            return (cast(T)(new 条件表达式_(tsk, 开始, 结束)));
        }
        case KSK.类型查询表达式: {
            return (cast(T)(new 类型查询表达式_(tsk, 开始, 结束)));
        }
        case KSK.类型断言表达式: {
            return (cast(T)(new 类型断言表达式_(tsk, 开始, 结束)));
        }
        case KSK.箭头函数: {
            return (cast(T)(new 箭头函数_(tsk, 开始, 结束)));
        }
        case KSK.表达式包含类型实参: {
            return (cast(T)(new 表达式包含类型实参_(tsk, 开始, 结束)));
        }
        case KSK.部分输出表达式: {
            return (cast(T)(new 部分输出表达式_(tsk, 开始, 结束)));
        }
        case KSK.若是子句: {
            return (cast(T)(new 若是子句_(tsk, 开始, 结束)));
        }
        case KSK.默认子句: {
            return (cast(T)(new 默认子句_(tsk, 开始, 结束)));
        }
        case KSK.结构字面量表达式: {
            return (cast(T)(new 结构字面量表达式_(tsk, 开始, 结束)));
        }
        case KSK.省略表达式: {
            return (cast(T)(new 省略表达式_(tsk, 开始, 结束)));
        }
        case KSK.只读_:
        case KSK.恒定_:
        case KSK.共享_:
        case KSK.静态_:
        case KSK.返回_:
        case KSK.局部_:
        case KSK.引用_:
        case KSK.固定_:
        case KSK.公开_:
        case KSK.私有_:
        case KSK.保护_:
        case KSK.重载_:
        case KSK.返回局部引用_:
        case KSK.返回引用_:
        case KSK.局部引用_:
        case KSK.返回局部_:
        case KSK.同步_:
        case KSK.导出_:
        case KSK.左大括号:
        case KSK.右大括号:
        case KSK.左括号:
        case KSK.右括号:
        case KSK.左方括号:
        case KSK.右方括号:
        case KSK.双引号:
        case KSK.单引号:
        case KSK.点号:
        case KSK.分号:
        case KSK.逗号:
        case KSK.左尖括号:
        case KSK.右尖括号:
        case KSK.加号:
        case KSK.减号:
        case KSK.星号:
        case KSK.反斜杠:
        case KSK.除号:
        case KSK.百分号:
        case KSK.且号:
        case KSK.或号:
        case KSK.异或号:
        case KSK.叹号:
        case KSK.波折号:
        case KSK.美元:
        case KSK.问号:
        case KSK.冒号:
        case KSK.艾特:
        case KSK.井号:
        case KSK.反引号:
        case KSK.等号:
        case KSK.冒等号:
        case KSK.等右尖号:
        case KSK.三点号:
        case KSK.二点号:
        case KSK.点左方括号:
        case KSK.点左尖括号:
        case KSK.点左括号:
        case KSK.问点号:
        case KSK.左尖等号:
        case KSK.右尖等号:
        case KSK.等等号:
        case KSK.叹等号:
        case KSK.且且号:
        case KSK.或或号:
        case KSK.加加号:
        case KSK.减减号:
        case KSK.左左尖号:
        case KSK.右右尖号:
        case KSK.右右右尖号:
        case KSK.加等号:
        case KSK.减等号:
        case KSK.星等号:
        case KSK.除等号:
        case KSK.余等号:
        case KSK.连接等号:
        case KSK.左左尖等号:
        case KSK.右右尖等号:
        case KSK.右右右尖等号:
        case KSK.且等号:
        case KSK.或等号:
        case KSK.异或等号:
        case KSK.跳出_:
        case KSK.断言_:
        case KSK.构建_:
        case KSK.释放_:
        case KSK.常量_:
        case KSK.外部_:
        case KSK.C_:
        case KSK.C加加_:
        case KSK.D_:
        case KSK.Windows_:
        case KSK.System_:
        case KSK.Objective_C_:
        case KSK.异步_:
        case KSK.等待_:
        case KSK.继续_:
        case KSK.调试_:
        case KSK.默认_:
        case KSK.删除_:
        case KSK.否则_:
        case KSK.枚举_:
        case KSK.假_:
        case KSK.循环_:
        case KSK.函数_:
        case KSK.如果_:
        case KSK.导入_:
        case KSK.新建_:
        case KSK.若是_:
        case KSK.抛出_:
        case KSK.尝试_:
        case KSK.捕获_:
        case KSK.最后_:
        case KSK.全局_:
        case KSK.事件_:
        case KSK.对象_:
        case KSK.结构_:
        case KSK.别名_:
        case KSK.延迟_:
        case KSK.另如_:
        case KSK.程序_:
        case KSK.启动_:
        case KSK.初始_:
        case KSK.整数_:
        case KSK.正整数_:
        case KSK.小数_:
        case KSK.正量_:
        case KSK.指针_:
        case KSK.原型_:
        case KSK.未知_:
        case KSK.零值_:
        case KSK.空址_:
        case KSK.空值_:
        case KSK.假如_:
        case KSK.本体_:
        case KSK.基类_:
        case KSK.真_:
        case KSK.不及_:
        case KSK.无值_:
        case KSK.接口_:
        case KSK.通用_:
        case KSK.变量_:
        case KSK.真假_:
        case KSK.文本_:
        case KSK.文本8_:
        case KSK.文本16_:
        case KSK.文本32_:
        case KSK.类型_:
        case KSK.指令_:
        case KSK.汇编_:
        case KSK.测试_:
        case KSK.版本_:
        case KSK.整数8_:
        case KSK.整数16_:
        case KSK.整数32_:
        case KSK.整数64_:
        case KSK.正整数8_:
        case KSK.正整数16_:
        case KSK.正整数32_:
        case KSK.正整数64_:
        case KSK.小数32_:
        case KSK.小数64_:
        case KSK.虚数32_:
        case KSK.虚数64_:
        case KSK.复数64_:
        case KSK.复数128_:
        case KSK.字符_:
        case KSK.字符8_:
        case KSK.字符16_:
        case KSK.字符32_:
        case KSK.字节_:
        case KSK.声明_:
        case KSK.属于_:
        case KSK.纯净_:
        case KSK.安全_:
        case KSK.信任_:
        case KSK.系统_:
        case KSK.无回收_:
        case KSK.不抛出_: {
            return (cast(T)(new Klang令牌_!(KSK)(tsk)));
        }
        default: break;
    }
    return (cast(T)(new Klang节点_(tsk, 开始, 结束)));
}
bool 有修饰符(Klang节点_ n, 修饰符标志_ 标志) {
    return .获取选择的修饰符组(n, 标志) != 修饰符标志_.无_;
}
bool 有静态修饰符(Klang节点_ n) {
    return .有修饰符(n, 修饰符标志_.静态_);
}
bool 有只读修饰符(Klang节点_ n) {
    return .有修饰符(n, 修饰符标志_.只读_);
}
修饰符标志_ 获取选择的修饰符组(Klang节点_ n, 修饰符标志_ 标志) {
    return .获取修饰符组(n) & 标志;
}
修饰符标志_ 获取修饰符组(Klang节点_ n) {
    if (n.修饰符缓存 != 修饰符标志_.无_ && (n.修饰符缓存 & 修饰符标志_.有计算标志) != 0) {
        return n.修饰符缓存 & ~修饰符标志_.有计算标志;
    }
    修饰符标志_ 标志 = .获取修饰符不缓存(n);
    n.修饰符缓存 |= 标志;
    n.修饰符缓存 |= 修饰符标志_.有计算标志;
    return 标志;
}
修饰符标志_ 获取修饰符不缓存(Klang节点_ n) {
    修饰符标志_ 标志 = 修饰符标志_.无_;
    if ((n.修饰符 !is null) && (n.修饰符.原型 !is ··null!(修饰符_[]))) {
        foreach (修饰符_ 修饰符; n.修饰符) {
            标志 |= .修饰符种类转标志(修饰符.目标种类);
        }
    }
    return 标志;
}
修饰符标志_ 修饰符种类转标志(long token) {
    switch (token) {
        case KSK.只读_: {
            return 修饰符标志_.只读_;
        }
        case KSK.恒定_: {
            return 修饰符标志_.恒定_;
        }
        case KSK.共享_: {
            return 修饰符标志_.共享_;
        }
        case KSK.静态_: {
            return 修饰符标志_.静态_;
        }
        case KSK.引用_: {
            return 修饰符标志_.引用_;
        }
        case KSK.局部_: {
            return 修饰符标志_.局部_;
        }
        case KSK.固定_: {
            return 修饰符标志_.固定_;
        }
        case KSK.重载_: {
            return 修饰符标志_.重载_;
        }
        case KSK.返回_: {
            return 修饰符标志_.返回_;
        }
        case KSK.返回局部引用_: {
            return 修饰符标志_.返局引_;
        }
        case KSK.返回引用_: {
            return 修饰符标志_.返引_;
        }
        case KSK.局部引用_: {
            return 修饰符标志_.局引_;
        }
        case KSK.返回局部_: {
            return 修饰符标志_.返局_;
        }
        case KSK.私有_: {
            return 修饰符标志_.私有_;
        }
        case KSK.保护_: {
            return 修饰符标志_.保护_;
        }
        case KSK.外部修饰符声明: {
            return 修饰符标志_.外部_;
        }
        case KSK.导出_: {
            return 修饰符标志_.导出_;
        }
        case KSK.声明_: {
            return 修饰符标志_.声明_;
        }
        case KSK.纯净_: {
            return 修饰符标志_.纯净_;
        }
        case KSK.安全_: {
            return 修饰符标志_.安全_;
        }
        case KSK.信任_: {
            return 修饰符标志_.信任_;
        }
        case KSK.系统_: {
            return 修饰符标志_.系统_;
        }
        case KSK.无回收_: {
            return 修饰符标志_.无回收_;
        }
        case KSK.不抛出_: {
            return 修饰符标志_.不抛出_;
        }
        default: break;
    }
    return 修饰符标志_.无_;
}
bool 是展开表达式(Klang节点_ n) {
    return n.目标种类 == KSK.展开表达式;
}
bool 是类型引用(Klang节点_ n) {
    return n.目标种类 == KSK.类型引用;
}
类型引用_ 获取类型引用(Klang节点_ n) {
    if (.是类型引用(n)) {
        return (cast(类型引用_)(n));
    }
    return ··null!(类型引用_);
}
bool 是函数类型(Klang节点_ n) {
    return n.目标种类 == KSK.函数类型;
}
函数类型_ 获取函数类型(Klang节点_ n) {
    if (.是函数类型(n)) {
        return (cast(函数类型_)(n));
    }
    return ··null!(函数类型_);
}
bool 是类型列表(Klang节点_ n) {
    return n.目标种类 == KSK.类型列表;
}
类型列表_ 获取类型列表(Klang节点_ n) {
    if (.是类型列表(n)) {
        return (cast(类型列表_)(n));
    }
    return ··null!(类型列表_);
}
bool 是括号类型(Klang节点_ n) {
    return n.目标种类 == KSK.括号类型;
}
括号类型_ 获取括号类型(Klang节点_ n) {
    if (.是括号类型(n)) {
        return (cast(括号类型_)(n));
    }
    return ··null!(括号类型_);
}
bool 是类型查询表达式(Klang节点_ n) {
    return n.目标种类 == KSK.类型查询表达式;
}
bool 是符号引用表达式(Klang节点_ n) {
    return n.目标种类 == KSK.符号引用表达式;
}
符号引用表达式_ 获取符号引用表达式(Klang节点_ n) {
    if (.是符号引用表达式(n)) {
        return (cast(符号引用表达式_)(n));
    }
    return ··null!(符号引用表达式_);
}
bool 是表达式包含类型实参(Klang节点_ n) {
    return n.目标种类 == KSK.表达式包含类型实参;
}
表达式包含类型实参_ 获取表达式包含类型实参(Klang节点_ n) {
    if (.是表达式包含类型实参(n)) {
        return (cast(表达式包含类型实参_)(n));
    }
    return ··null!(表达式包含类型实参_);
}
bool 是类型限定类型(Klang节点_ n) {
    return n.目标种类 == KSK.类型限定类型;
}
类型限定类型_ 获取类型限定类型(Klang节点_ n) {
    if (.是类型限定类型(n)) {
        return (cast(类型限定类型_)(n));
    }
    return ··null!(类型限定类型_);
}
bool 是数组类型节点(Klang节点_ n) {
    return n.目标种类 == KSK.数组类型;
}
bool 是动态数组类型节点(Klang节点_ n) {
    return n.目标种类 == KSK.动态数组类型;
}
bool 是词典类型节点(Klang节点_ n) {
    return n.目标种类 == KSK.词典类型;
}
bool 是元素访问表达式(Klang节点_ n) {
    return n.目标种类 == KSK.元素访问表达式;
}
bool 是程序声明(节点.节点_ n) {
    return n.目标种类 == KSK.程序声明;
}
程序声明_ 获取程序声明(节点.节点_ n) {
    if (.是程序声明(n)) {
        return (cast(程序声明_)(n));
    }
    return ··null!(程序声明_);
}
bool 是类型断言表达式(Klang节点_ n) {
    return n.目标种类 == KSK.类型断言表达式;
}
元素访问表达式_ 获取元素访问表达式(Klang节点_ n) {
    if (.是截取表达式(n)) {
        return (cast(元素访问表达式_)(n));
    }
    return ··null!(元素访问表达式_);
}
bool 是截取表达式(Klang节点_ n) {
    return n.目标种类 == KSK.截取表达式;
}
截取表达式_ 获取截取表达式(Klang节点_ n) {
    if (.是截取表达式(n)) {
        return (cast(截取表达式_)(n));
    }
    return ··null!(截取表达式_);
}
bool 是klang节点(节点.节点_ n) {
    return n.目标 == TK.Klang && n.种类 != SK.源文件;
}
Klang节点_ 获取Klang节点(节点.节点_ n) {
    if (.是klang节点(n)) {
        return (cast(Klang节点_)(n));
    }
    return ··null!(Klang节点_);
}
bool 是源文件(节点.节点_ n) {
    return n.目标种类 == KSK.源文件;
}
Klang源文件_ 获取源文件(节点.节点_ n) {
    if (.是源文件(n)) {
        return (cast(Klang源文件_)(获取基础源文件(n)));
    }
    return ··null!(Klang源文件_);
}
bool 是导入成员(Klang节点_ n) {
    return n.目标种类 == KSK.导入成员;
}
bool 是导入版本成员(Klang节点_ n) {
    return n.目标种类 == KSK.导入版本成员;
}
bool 是导入成员块(Klang节点_ n) {
    return n.目标种类 == KSK.导入成员块;
}
bool 是函数声明(Klang节点_ n) {
    return n.目标种类 == KSK.函数声明;
}
bool 是初始函数(Klang节点_ n) {
    return (n.标志 & 节点标志_.是初始函数) != 0;
}
bool 是启动函数(Klang节点_ n) {
    return (n.标志 & 节点标志_.是启动函数) != 0;
}
bool 是测试启动函数(Klang节点_ n) {
    return (n.标志 & 节点标志_.是测试启动函数) != 0;
}
bool 是启动或测试启动函数(Klang节点_ n) {
    return .是启动函数(n) || .是测试启动函数(n);
}
bool 是函数表达式(Klang节点_ n) {
    return n.目标种类 == KSK.函数表达式;
}
bool 是箭头函数(Klang节点_ n) {
    return n.目标种类 == KSK.箭头函数;
}
bool 是方法声明(Klang节点_ n) {
    return n.目标种类 == KSK.方法声明;
}
bool 是构建声明(Klang节点_ n) {
    return n.目标种类 == KSK.构建声明;
}
bool 是释放声明(Klang节点_ n) {
    return n.目标种类 == KSK.释放声明;
}
bool 是函数类型节点(Klang节点_ n) {
    return n.目标种类 == KSK.函数类型;
}
bool 是函数类的(Klang节点_ n) {
    return .是函数声明(n) || .是函数表达式(n) || .是箭头函数(n) || .是方法声明(n) || .是构建声明(n) || .是释放声明(n) || .是函数类型节点(n);
}
bool 是函数类声明(Klang节点_ n) {
    return .是函数声明(n) || .是函数表达式(n) || .是箭头函数(n) || .是方法声明(n) || .是构建声明(n) || .是释放声明(n);
}
bool 是循环语句(Klang节点_ n) {
    return n.目标种类 == KSK.循环语句;
}
bool 是循环属于(Klang节点_ n) {
    return n.目标种类 == KSK.循环属于;
}
bool 是循环或循环属于语句(Klang节点_ n) {
    return .是循环语句(n) || .是循环属于(n);
}
bool 是块(Klang节点_ n) {
    return n.目标种类 == KSK.块;
}
块_ 获取块(Klang节点_ n) {
    if (.是块(n)) {
        return (cast(块_)(n));
    }
    return ··null!(块_);
}
bool isBlockScope(节点.节点_ node, 节点.节点_ parentNode) {
    switch (node.目标种类) {
        case KSK.源文件:
        case KSK.若是块:
        case KSK.捕获子句:
        case KSK.循环语句:
        case KSK.循环属于:
        case KSK.构建声明:
        case KSK.释放声明:
        case KSK.方法声明:
        case KSK.函数声明:
        case KSK.函数表达式:
        case KSK.箭头函数:
        case KSK.同步语句:
        case KSK.测试单元语句: {
            return true;
        }
        case KSK.块: {
            return !.是函数类的((cast(Klang节点_)(parentNode))) && !.是循环或循环属于语句((cast(Klang节点_)(parentNode))) && .是容器块((cast(块_)((cast(Klang节点_)(node)))));
        }
        default: break;
    }
    return false;
}
bool 是容器块(Klang节点_ node) {
    块_ nn = .获取块(node);
    if (nn !is ··null!(块_)) {
        return nn.版本容器块种类 == 版本容器块种类_.无_;
    }
    return false;
}
bool 是枚举声明(Klang节点_ n) {
    return n.目标种类 == KSK.枚举声明;
}
bool 是变量语句(Klang节点_ n) {
    return n.目标种类 == KSK.变量语句;
}
bool 是新建表达式(Klang节点_ n) {
    return n.目标种类 == KSK.新建表达式;
}
bool 是语句但不是声明(long kind) {
    return kind == KSK.跳出语句 || kind == KSK.删除语句 || kind == KSK.延迟语句 || kind == KSK.指令语句 || kind == KSK.测试单元语句 || kind == KSK.断言语句 || kind == KSK.同步语句 || kind == KSK.继续语句 || kind == KSK.调试语句 || kind == KSK.表达式语句 || kind == KSK.空语句 || kind == KSK.循环语句 || kind == KSK.循环属于 || kind == KSK.如果语句 || kind == KSK.标签语句 || kind == KSK.当循环语句 || kind == KSK.返回语句 || kind == KSK.假如语句 || kind == KSK.变量语句 || kind == KSK.版本表达式语句;
}
bool 是属性访问表达式(Klang节点_ n) {
    return n.目标种类 == KSK.属性访问表达式;
}
bool 是非空表达式(Klang节点_ n) {
    return n.目标种类 == KSK.非空表达式;
}
bool 是klang文本字面量(Klang节点_ n) {
    return n.目标种类 == KSK.文本字面量;
}
bool 是klang数字字面量(Klang节点_ n) {
    return n.目标种类 == KSK.数字字面量;
}
/* @internal */
bool 是字面量种类(KSK ksk) {
    return KSK.第一个字面量 <= ksk && ksk <= KSK.最后一个字面量 || KSK.第一个字面量klang <= ksk && ksk <= KSK.最后一个字面量klang;
}
/* @internal */
bool 是模板字面量种类(KSK ksk) {
    return KSK.第一个模板 <= ksk && ksk <= KSK.最后一个模板;
}
bool 是逻辑运算符(KSK ksk) {
    return ksk == KSK.或或号 || ksk == KSK.且且号 || ksk == KSK.叹号;
}
bool 是赋值运算符(KSK ksk) {
    return ksk == KSK.等号 || ksk >= KSK.第一个复合赋值 && ksk <= KSK.最后一个复合赋值;
}
bool 遍历节点(节点.节点_ node, bool delegate(节点.节点_) cbNode, bool delegate(节点.节点数组_!(节点.节点_)) cbNodes = ··null!(bool delegate(节点.节点数组_!(节点.节点_)))) {
    if ((node is ··null!(节点.节点_)) || node.种类 <= SK.标识符) {
        return false;
    }
    if (node.种类 == SK.源文件) {
        Klang源文件_ sou = (cast(Klang源文件_)((cast(节点.源文件_)(node))));
        return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), sou.语句组) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), sou.文件结尾令牌);
    }
    Klang节点_ k节点 = .获取Klang节点(node);
    if (k节点 is ··null!(Klang节点_)) {
        return false;
    }
    long k = k节点.目标种类;
    switch (k) {
        case KSK.标识符: {
            Klang标识符_ n = (cast(Klang标识符_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.标识符);
        }
        case KSK.限定名: {
            限定名_ n = (cast(限定名_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.左侧) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.右侧);
        }
        case KSK.类型引用: {
            类型引用_ n = (cast(类型引用_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型名称) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型实参组));
        }
        case KSK.静态二元表达式类型节点: {
            静态二元表达式类型节点_ n = (cast(静态二元表达式类型节点_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.左侧) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.右侧);
        }
        case KSK.函数类型: {
            函数类型_ n = (cast(函数类型_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型形参)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.形参组)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case KSK.区间类型节点: {
            区间类型节点_ n = (cast(区间类型节点_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.区间开始) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.区间结束);
        }
        case KSK.数组类型: {
            数组类型_ n = (cast(数组类型_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.长度);
        }
        case KSK.元组类型节点: {
            元组类型节点_ n = (cast(元组类型节点_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型组));
        }
        case KSK.类型列表: {
            类型列表_ n = (cast(类型列表_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型组));
        }
        case KSK.联合类型: {
            联合类型_ n = (cast(联合类型_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型组));
        }
        case KSK.括号类型: {
            括号类型_ n = (cast(括号类型_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case KSK.词典类型: {
            词典类型_ n = (cast(词典类型_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.键类型);
        }
        case KSK.动态数组类型: {
            动态数组类型_ n = (cast(动态数组类型_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case KSK.指针类型: {
            指针类型_ n = (cast(指针类型_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case KSK.变长参数: {
            变长参数_ n = (cast(变长参数_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case KSK.类型限定类型: {
            类型限定类型_ n = (cast(类型限定类型_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case KSK.字面量类型: {
            字面量类型_ n = (cast(字面量类型_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.字面量);
        }
        case KSK.类型形参: {
            类型形参_ n = (cast(类型形参_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.约束);
        }
        case KSK.导入成员: {
            导入成员_ n = (cast(导入成员_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.模块名) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.另命名名称);
        }
        case KSK.导入从成员: {
            导入从成员_ n = (cast(导入从成员_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.另命名名称) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称);
        }
        case KSK.导入声明: {
            导入声明_ n = (cast(导入声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.导入组));
        }
        case KSK.导入从声明: {
            导入从声明_ n = (cast(导入从声明_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.模块名) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.导入组));
        }
        case KSK.导入版本成员: {
            导入版本成员_ n = (cast(导入版本成员_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.然后语句) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.否则语句);
        }
        case KSK.导入成员块: {
            导入成员块_ n = (cast(导入成员块_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.语句组));
        }
        case KSK.导入从成员块: {
            导入从成员块_ n = (cast(导入从成员块_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.语句组));
        }
        case KSK.导入从版本成员: {
            导入从版本成员_ n = (cast(导入从版本成员_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.然后语句) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.否则语句);
        }
        case KSK.版本表达式语句: {
            版本表达式语句_ n = (cast(版本表达式语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.断言语句: {
            断言语句_ n = (cast(断言语句_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.实参组));
        }
        case KSK.版本语句: {
            版本语句_ n = (cast(版本语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.然后语句) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.否则语句);
        }
        case KSK.测试单元语句: {
            测试单元语句_ n = (cast(测试单元语句_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.语句组));
        }
        case KSK.块: {
            块_ n = (cast(块_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.语句组));
        }
        case KSK.如果语句: {
            如果语句_ n = (cast(如果语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.然后语句) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.否则语句);
        }
        case KSK.指令语句: {
            指令语句_ n = (cast(指令语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.参数);
        }
        case KSK.程序声明: {
            程序声明_ n = (cast(程序声明_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.语句组)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.结尾令牌);
        }
        case KSK.变量语句: {
            变量语句_ n = (cast(变量语句_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.声明列表);
        }
        case KSK.外部修饰符声明: {
            外部修饰符声明_ n = (cast(外部修饰符声明_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.修饰符节点) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称空间);
        }
        case KSK.标识符修饰符: {
            标识符修饰符_ n = (cast(标识符修饰符_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.标识符);
        }
        case KSK.形参声明: {
            形参声明_ n = (cast(形参声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.初始化);
        }
        case KSK.变量声明列表: {
            变量声明列表_ n = (cast(变量声明列表_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.声明组));
        }
        case KSK.变量声明: {
            变量声明_ n = (cast(变量声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.叹号令牌) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.初始化);
        }
        case KSK.索引签名: {
            索引签名_ n = (cast(索引签名_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.形参) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case KSK.运算符签名: {
            运算符签名_ n = (cast(运算符签名_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.运算符组)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case KSK.运算符签名元素: {
            运算符签名元素_ n = (cast(运算符签名元素_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case KSK.函数声明: {
            函数声明_ n = (cast(函数声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型形参)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.形参组)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.函数体);
        }
        case KSK.方法声明: {
            方法声明_ n = (cast(方法声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型形参)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.形参组)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.函数体);
        }
        case KSK.枚举成员: {
            枚举成员_ n = (cast(枚举成员_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.初始化);
        }
        case KSK.属性声明: {
            属性声明_ n = (cast(属性声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.初始化);
        }
        case KSK.构建声明: {
            构建声明_ n = (cast(构建声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型形参)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.形参组)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.函数体);
        }
        case KSK.释放声明: {
            释放声明_ n = (cast(释放声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型形参)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.形参组)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.函数体);
        }
        case KSK.枚举声明: {
            枚举声明_ n = (cast(枚举声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.成员组));
        }
        case KSK.接口声明: {
            接口声明_ n = (cast(接口声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型形参)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.继承子句)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.成员组));
        }
        case KSK.对象声明: {
            对象声明_ n = (cast(对象声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型形参)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.继承子句)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.成员组));
        }
        case KSK.结构声明: {
            结构声明_ n = (cast(结构声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型形参)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.继承子句)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.成员组));
        }
        case KSK.类型声明: {
            类型声明_ n = (cast(类型声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型形参)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.成员组));
        }
        case KSK.别名声明: {
            别名声明_ n = (cast(别名声明_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型形参)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case KSK.继承子句: {
            继承子句_ n = (cast(继承子句_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型组));
        }
        case KSK.模板中: {
            模板中_ n = (cast(模板中_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.模板尾: {
            模板尾_ n = (cast(模板尾_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.前缀一元表达式: {
            前缀一元表达式_ n = (cast(前缀一元表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.后缀一元表达式: {
            后缀一元表达式_ n = (cast(后缀一元表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.二元表达式: {
            二元表达式_ n = (cast(二元表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.左侧) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.右侧);
        }
        case KSK.属性访问表达式: {
            属性访问表达式_ n = (cast(属性访问表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.左侧) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称);
        }
        case KSK.元素访问表达式: {
            元素访问表达式_ n = (cast(元素访问表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.参数表达式);
        }
        case KSK.新建表达式: {
            新建表达式_ n = (cast(新建表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.实参组));
        }
        case KSK.调用表达式: {
            调用表达式_ n = (cast(调用表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型实参组)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.实参组));
        }
        case KSK.数组字面量表达式: {
            数组字面量表达式_ n = (cast(数组字面量表达式_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.元素组));
        }
        case KSK.表达式列表表达式: {
            表达式列表表达式_ n = (cast(表达式列表表达式_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.元素组));
        }
        case KSK.动态类字面量表达式: {
            动态类字面量表达式_ n = (cast(动态类字面量表达式_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.元素组));
        }
        case KSK.词典键值表达式: {
            词典键值表达式_ n = (cast(词典键值表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.键表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值表达式);
        }
        case KSK.结构字面量表达式: {
            结构字面量表达式_ n = (cast(结构字面量表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型注释节点) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.属性组));
        }
        case KSK.接口字面量表达式: {
            接口字面量表达式_ n = (cast(接口字面量表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.属性组));
        }
        case KSK.函数表达式: {
            函数表达式_ n = (cast(函数表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型形参)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.形参组)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.函数体);
        }
        case KSK.模板表达式: {
            模板表达式_ n = (cast(模板表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.模板头) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.模板跨度)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.模板尾);
        }
        case KSK.非空表达式: {
            非空表达式_ n = (cast(非空表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.截取表达式: {
            截取表达式_ n = (cast(截取表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.截取开始) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.截取结尾);
        }
        case KSK.展开表达式: {
            展开表达式_ n = (cast(展开表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.属性赋值: {
            属性赋值_ n = (cast(属性赋值_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.初始化);
        }
        case KSK.简洁属性赋值: {
            简洁属性赋值_ n = (cast(简洁属性赋值_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.名称) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.初始化);
        }
        case KSK.条件表达式: {
            条件表达式_ n = (cast(条件表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.条件) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.当真) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.当假);
        }
        case KSK.类型查询表达式: {
            类型查询表达式_ n = (cast(类型查询表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case KSK.类型断言表达式: {
            类型断言表达式_ n = (cast(类型断言表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.类型转换表达式: {
            类型转换表达式_ n = (cast(类型转换表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case KSK.箭头函数: {
            箭头函数_ n = (cast(箭头函数_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型形参)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.形参组)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.等右尖号) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.函数体);
        }
        case KSK.表达式包含类型实参: {
            表达式包含类型实参_ n = (cast(表达式包含类型实参_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型实参组));
        }
        case KSK.符号引用表达式: {
            符号引用表达式_ n = (cast(符号引用表达式_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.修饰符)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.部分输出表达式: {
            部分输出表达式_ n = (cast(部分输出表达式_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.循环属于: {
            循环属于_ n = (cast(循环属于_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.初始化) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.语句);
        }
        case KSK.循环语句: {
            循环语句_ n = (cast(循环语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.初始化) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.条件) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.自增) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.语句);
        }
        case KSK.当循环语句: {
            当循环语句_ n = (cast(当循环语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.语句);
        }
        case KSK.跳出语句: {
            跳出语句_ n = (cast(跳出语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.标签);
        }
        case KSK.继续语句: {
            继续语句_ n = (cast(继续语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.标签);
        }
        case KSK.延迟语句: {
            延迟语句_ n = (cast(延迟语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.语句);
        }
        case KSK.删除语句: {
            删除语句_ n = (cast(删除语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.返回语句: {
            返回语句_ n = (cast(返回语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.假如语句: {
            假如语句_ n = (cast(假如语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.若是块);
        }
        case KSK.若是块: {
            若是块_ n = (cast(若是块_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.子句组));
        }
        case KSK.抛出语句: {
            抛出语句_ n = (cast(抛出语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.同步语句: {
            同步语句_ n = (cast(同步语句_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.实参组)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.语句组));
        }
        case KSK.尝试语句: {
            尝试语句_ n = (cast(尝试语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.尝试块) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.捕获子句) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.最后块);
        }
        case KSK.捕获子句: {
            捕获子句_ n = (cast(捕获子句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.变量声明) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.块);
        }
        case KSK.标签语句: {
            标签语句_ n = (cast(标签语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.标签) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.语句);
        }
        case KSK.表达式语句: {
            表达式语句_ n = (cast(表达式语句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case KSK.若是子句: {
            若是子句_ n = (cast(若是子句_)(k节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.语句组));
        }
        case KSK.默认子句: {
            默认子句_ n = (cast(默认子句_)(k节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.语句组));
        }
        case KSK.调试语句:
        case KSK.字符字面量:
        case KSK.小数字面量:
        case KSK.正则表达式字面量:
        case KSK.空语句:
        case KSK.失踪声明:
        case KSK.无替换模板字面量:
        case KSK.模板头: {
            return false;
        }
        default: break;
    }
    return false;
}
